Method: lambda$6(OWLClassJ, OWLClassJ)

1: /**
2: * Copyright (C) 2022 Czech Technical University in Prague
3: * <p>
4: * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
5: * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
6: * version.
7: * <p>
8: * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9: * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
10: * details. You should have received a copy of the GNU General Public License along with this program. If not, see
11: * <http://www.gnu.org/licenses/>.
12: */
13: package cz.cvut.kbss.jopa.test.query.runner;
14:
15: import cz.cvut.kbss.jopa.model.query.TypedQuery;
16: import cz.cvut.kbss.jopa.model.query.criteria.CriteriaQuery;
17: import cz.cvut.kbss.jopa.model.query.criteria.ParameterExpression;
18: import cz.cvut.kbss.jopa.model.query.criteria.Predicate;
19: import cz.cvut.kbss.jopa.model.query.criteria.Root;
20: import cz.cvut.kbss.jopa.sessions.CriteriaBuilder;
21: import cz.cvut.kbss.jopa.test.*;
22: import cz.cvut.kbss.jopa.test.environment.DataAccessor;
23: import cz.cvut.kbss.jopa.test.environment.Generators;
24: import cz.cvut.kbss.jopa.test.environment.TestEnvironment;
25: import cz.cvut.kbss.jopa.test.query.QueryTestEnvironment;
26: import cz.cvut.kbss.ontodriver.model.LangString;
27: import org.junit.jupiter.api.Test;
28: import org.slf4j.Logger;
29:
30: import java.util.ArrayList;
31: import java.util.Comparator;
32: import java.util.List;
33: import java.util.Set;
34: import java.util.stream.Collectors;
35:
36: import static cz.cvut.kbss.jopa.test.environment.util.ContainsSameEntities.containsSameEntities;
37: import static org.hamcrest.MatcherAssert.assertThat;
38: import static org.hamcrest.Matchers.lessThanOrEqualTo;
39: import static org.junit.jupiter.api.Assertions.*;
40:
41: public abstract class CriteriaRunner extends BaseQueryRunner {
42:
43: protected CriteriaRunner(Logger logger, DataAccessor dataAccessor) {
44: super(logger, dataAccessor);
45: }
46:
47: @Test
48: public void testSimpleFindAll() {
49: final List<OWLClassA> expected = QueryTestEnvironment.getData(OWLClassA.class);
50: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
51: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
52: Root<OWLClassA> root = query.from(OWLClassA.class);
53: query.select(root);
54: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
55: final List<OWLClassA> result = tq.getResultList();
56:
57: assertEquals(expected.size(), result.size());
58: for (OWLClassA a : result) {
59: assertNotNull(a.getStringAttribute());
60: assertTrue(expected.stream().anyMatch(aa -> aa.getUri().equals(a.getUri())));
61: }
62: }
63:
64: @Test
65: public void testSimpleCount() {
66: final List<OWLClassA> expected = QueryTestEnvironment.getData(OWLClassA.class);
67: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
68: CriteriaQuery<Integer> query = cb.createQuery(Integer.class);
69: Root<OWLClassA> root = query.from(OWLClassA.class);
70: query.select(cb.count(root));
71: final Integer result = getEntityManager().createQuery(query).getSingleResult();
72:
73: assertEquals(expected.size(), result);
74: }
75:
76: @Test
77: public void testFindByDataPropertyAttribute() {
78: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
79: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
80: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
81: Root<OWLClassA> root = query.from(OWLClassA.class);
82: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), expected.getStringAttribute(), "en");
83: query.select(root).where(restriction);
84: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
85: final OWLClassA result = tq.getSingleResult();
86:
87: assertEquals(expected.getUri(), result.getUri());
88: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
89: assertEquals(expected.getTypes(), result.getTypes());
90: }
91:
92: @Test
93: public void testFindByDataNotPropertyAttribute() {
94: final OWLClassA unexpected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
95: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
96: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
97: Root<OWLClassA> root = query.from(OWLClassA.class);
98: Predicate restriction =
99: cb.equal(root.getAttr(OWLClassA_.stringAttribute), unexpected.getStringAttribute(), "en");
100: query.select(root).where(cb.not(restriction));
101: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
102: final List<OWLClassA> result = tq.getResultList();
103:
104: for (OWLClassA item : result) {
105: assertNotEquals(unexpected.getUri(), item.getUri());
106: assertNotEquals(unexpected.getStringAttribute(), item.getStringAttribute());
107: }
108: }
109:
110: @Test
111: public void testFindByDataNotPropertyAttributeAndPropertyAttribute() {
112: final OWLClassT unexpected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
113: final int intThreshold = QueryTestEnvironment.getData(OWLClassT.class).size() / 2;
114: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
115: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
116: Root<OWLClassT> root = query.from(OWLClassT.class);
117: Predicate firstRestriction = cb.not(cb.equal(root.getAttr("owlClassA"), unexpected.getOwlClassA().getUri()));
118: Predicate secondRestriction = cb.lessThan(root.getAttr("intAttribute"), intThreshold);
119: Predicate restrictions = cb.and(firstRestriction, secondRestriction);
120: query.select(root).where(restrictions);
121: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
122: final List<OWLClassT> result = tq.getResultList();
123:
124: assertFalse(result.isEmpty());
125: for (OWLClassT item : result) {
126: assertNotEquals(unexpected.getUri(), item.getUri());
127: assertTrue(intThreshold > item.getIntAttribute());
128: }
129: }
130:
131: @Test
132: public void testFindByObjectPropertyAttribute() {
133: final OWLClassD expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassD.class));
134: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
135: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
136: Root<OWLClassD> root = query.from(OWLClassD.class);
137: Predicate restriction = cb.equal(root.getAttr("owlClassA"), expected.getOwlClassA().getUri());
138: query.select(root).where(restriction);
139: TypedQuery<OWLClassD> tq = getEntityManager().createQuery(query);
140: final OWLClassD result = tq.getSingleResult();
141:
142: assertEquals(expected.getUri(), result.getUri());
143: assertEquals(expected.getOwlClassA().getUri(), result.getOwlClassA().getUri());
144: }
145:
146: @Test
147: public void testFindByConjunctionOfAttributes() {
148: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
149: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
150: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
151: Root<OWLClassT> root = query.from(OWLClassT.class);
152: Predicate firstRestriction = cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri());
153: Predicate secondRestriction = cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute());
154: query.select(root).where(firstRestriction, secondRestriction);
155: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
156: final List<OWLClassT> result = tq.getResultList();
157:
158: assertFalse(result.isEmpty());
159: for (OWLClassT item : result) {
160: assertEquals(sample.getOwlClassA().getUri(), item.getOwlClassA().getUri());
161: assertThat(item.getIntAttribute(), lessThanOrEqualTo(sample.getIntAttribute()));
162: }
163: }
164:
165: @Test
166: public void testFindByConjunctionOfAttributesInList() {
167: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
168: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
169: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
170: Root<OWLClassT> root = query.from(OWLClassT.class);
171: List<Predicate> restrictions = new ArrayList<>();
172: restrictions.add(cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri()));
173: restrictions.add(cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute()));
174: query.select(root).where(restrictions);
175: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
176: final List<OWLClassT> result = tq.getResultList();
177:
178: assertFalse(result.isEmpty());
179: for (OWLClassT item : result) {
180: assertEquals(sample.getOwlClassA().getUri(), item.getOwlClassA().getUri());
181: assertThat(item.getIntAttribute(), lessThanOrEqualTo(sample.getIntAttribute()));
182: }
183: }
184:
185: @Test
186: public void testOrderBy() {
187: final List<OWLClassT> expected = QueryTestEnvironment.getData(OWLClassT.class);
188: expected.sort(Comparator.comparing(OWLClassT::getIntAttribute));
189: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
190: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
191: Root<OWLClassT> root = query.from(OWLClassT.class);
192: query.select(root).orderBy(cb.asc(root.getAttr("intAttribute")));
193: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
194: final List<OWLClassT> result = tq.getResultList();
195:
196: assertEquals(expected.size(), result.size());
197: for (OWLClassT t : result) {
198: assertTrue(expected.stream().anyMatch(tt -> tt.getUri().equals(t.getUri())));
199: }
200: }
201:
202: @Test
203: public void testFindByDisjunctionOfAttributes() {
204: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
205: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
206: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
207: Root<OWLClassT> root = query.from(OWLClassT.class);
208: Predicate firstRestriction = cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri());
209: Predicate secondRestriction = cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute());
210: query.select(root).where(cb.or(firstRestriction, secondRestriction));
211: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
212: final List<OWLClassT> result = tq.getResultList();
213:
214: assertFalse(result.isEmpty());
215: for (OWLClassT item : result) {
216: boolean matches = item.getOwlClassA().getUri().equals(sample.getOwlClassA().getUri());
217: matches |= item.getIntAttribute() <= sample.getIntAttribute();
218: assertTrue(matches);
219: }
220: }
221:
222: @Test
223: public void testFindByTransitiveAttributeValue() {
224: final OWLClassD expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassD.class));
225: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
226: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
227: Root<OWLClassD> root = query.from(OWLClassD.class);
228: Predicate restrictions = cb.equal(root.getAttr("owlClassA").getAttr("stringAttribute"),
229: expected.getOwlClassA().getStringAttribute(), "en");
230: query.select(root).where(restrictions);
231: TypedQuery<OWLClassD> tq = getEntityManager().createQuery(query);
232: final OWLClassD result = tq.getSingleResult();
233:
234: assertEquals(expected.getUri(), result.getUri());
235: assertEquals(expected.getOwlClassA().getUri(), result.getOwlClassA().getUri());
236: }
237:
238: @Test
239: public void testFindByParameterExpression() {
240: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
241: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
242: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
243: Root<OWLClassA> root = query.from(OWLClassA.class);
244: final ParameterExpression<String> strAtt = cb.parameter(String.class, "pOne");
245: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), strAtt);
246: query.select(root).where(restriction);
247: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
248: tq.setParameter(strAtt, expected.getStringAttribute(), "en");
249: final OWLClassA result = tq.getSingleResult();
250:
251: assertEquals(expected.getUri(), result.getUri());
252: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
253: assertEquals(expected.getTypes(), result.getTypes());
254: }
255:
256: @Test
257: public void testFindByUnnamedParameterExpression() {
258: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
259: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
260: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
261: Root<OWLClassA> root = query.from(OWLClassA.class);
262: final ParameterExpression<String> strAtt = cb.parameter(String.class);
263: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), strAtt);
264: query.select(root).where(restriction);
265: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
266: tq.setParameter(strAtt, expected.getStringAttribute(), "en");
267: final OWLClassA result = tq.getSingleResult();
268:
269: assertEquals(expected.getUri(), result.getUri());
270: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
271: assertEquals(expected.getTypes(), result.getTypes());
272: }
273:
274: @Test
275: public void testFindByLiteral() {
276: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
277: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
278: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
279: Root<OWLClassA> root = query.from(OWLClassA.class);
280: Predicate restriction =
281: cb.equal(root.getAttr(OWLClassA_.stringAttribute), cb.literal(expected.getStringAttribute(), "en"));
282: query.select(root).where(restriction);
283: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
284: final OWLClassA result = tq.getSingleResult();
285:
286: assertEquals(expected.getUri(), result.getUri());
287: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
288: assertEquals(expected.getTypes(), result.getTypes());
289: }
290:
291: @Test
292: public void testFindByAttributeValueIn() {
293: final List<OWLClassA> aInstances = QueryTestEnvironment.getData(OWLClassA.class);
294: final List<OWLClassA> matching;
295: if (Generators.randomBoolean()) {
296: matching = aInstances.subList(0, aInstances.size() / 2);
297: } else {
298: matching = aInstances.subList(aInstances.size() / 2, aInstances.size());
299: }
300: final List<OWLClassD> expected = QueryTestEnvironment.getData(OWLClassD.class).stream()
301: .filter(d -> matching.stream().anyMatch(
302: a -> d.getOwlClassA().getUri().equals(a.getUri())))
303: .collect(Collectors.toList());
304: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
305: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
306: Root<OWLClassD> root = query.from(OWLClassD.class);
307: query.select(root).where(root.getAttr("owlClassA").in(matching));
308:
309: final List<OWLClassD> result = getEntityManager().createQuery(query).getResultList();
310: assertThat(result, containsSameEntities(expected));
311: }
312:
313: /**
314: * Bug #135
315: */
316: @Test
317: public void testJoinOnPluralAttribute() {
318: final List<OWLClassJ> jInstances = QueryTestEnvironment.getData(OWLClassJ.class);
319: final OWLClassJ matching = Generators.getRandomItem(jInstances);
320: final Set<LangString> stringSet =
321: matching.getOwlClassA().stream()
322: .map(a -> new LangString(a.getStringAttribute(), TestEnvironment.PERSISTENCE_LANGUAGE))
323: .collect(Collectors.toSet());
324:
325: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
326: final CriteriaQuery<OWLClassJ> query = cb.createQuery(OWLClassJ.class);
327: final Root<OWLClassJ> root = query.from(OWLClassJ.class);
328: query.select(root).where(root.getAttr("owlClassA").getAttr("stringAttribute").in(stringSet));
329:
330: final List<OWLClassJ> result = getEntityManager().createQuery(query).getResultList();
331: assertFalse(result.isEmpty());
332: assertTrue(result.stream().anyMatch(j -> j.getUri().equals(matching.getUri())));
333: }
334:
335: @Test
336: public void testQueryOnlyRootWithEmptyWhereClauseWorks() {
337: final List<OWLClassA> aInstances = QueryTestEnvironment.getData(OWLClassA.class);
338: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
339: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
340: final Root<OWLClassA> root = query.from(OWLClassA.class);
341: query.select(root).where();
342:
343: final List<OWLClassA> result = getEntityManager().createQuery(query).getResultList();
344: assertThat(result, containsSameEntities(aInstances));
345: }
346: }